home *** CD-ROM | disk | FTP | other *** search
/ Chip 2007 January, February, March & April / Chip-Cover-CD-2007-02.iso / Pakiet bezpieczenstwa / mini Pentoo LiveCD 2006.1 / mpentoo-2006.1.iso / livecd.squashfs / usr / include / linux / mm.h < prev    next >
C/C++ Source or Header  |  2005-10-13  |  30KB  |  861 lines
  1. #ifndef _LINUX_MM_H
  2. #define _LINUX_MM_H
  3.  
  4. #include <linux/sched.h>
  5. #include <linux/errno.h>
  6.  
  7. #ifdef __KERNEL__
  8.  
  9. #include <linux/config.h>
  10. #include <linux/gfp.h>
  11. #include <linux/list.h>
  12. #include <linux/mmzone.h>
  13. #include <linux/rbtree.h>
  14. #include <linux/prio_tree.h>
  15. #include <linux/fs.h>
  16.  
  17. struct mempolicy;
  18. struct anon_vma;
  19.  
  20. #ifndef CONFIG_DISCONTIGMEM          /* Don't use mapnrs, do it properly */
  21. extern unsigned long max_mapnr;
  22. #endif
  23.  
  24. extern unsigned long num_physpages;
  25. extern void * high_memory;
  26. extern unsigned long vmalloc_earlyreserve;
  27. extern int page_cluster;
  28.  
  29. #ifdef CONFIG_SYSCTL
  30. extern int sysctl_legacy_va_layout;
  31. #else
  32. #define sysctl_legacy_va_layout 0
  33. #endif
  34.  
  35. #include <asm/page.h>
  36. #include <asm/pgtable.h>
  37. #include <asm/processor.h>
  38. #include <asm/atomic.h>
  39.  
  40. #ifndef MM_VM_SIZE
  41. #define MM_VM_SIZE(mm)    ((TASK_SIZE + PGDIR_SIZE - 1) & PGDIR_MASK)
  42. #endif
  43.  
  44. #define nth_page(page,n) pfn_to_page(page_to_pfn((page)) + (n))
  45.  
  46. /*
  47.  * Linux kernel virtual memory manager primitives.
  48.  * The idea being to have a "virtual" mm in the same way
  49.  * we have a virtual fs - giving a cleaner interface to the
  50.  * mm details, and allowing different kinds of memory mappings
  51.  * (from shared memory to executable loading to arbitrary
  52.  * mmap() functions).
  53.  */
  54.  
  55. /*
  56.  * This struct defines a memory VMM memory area. There is one of these
  57.  * per VM-area/task.  A VM area is any part of the process virtual memory
  58.  * space that has a special rule for the page-fault handlers (ie a shared
  59.  * library, the executable area etc).
  60.  */
  61. struct vm_area_struct {
  62.     struct mm_struct * vm_mm;    /* The address space we belong to. */
  63.     unsigned long vm_start;        /* Our start address within vm_mm. */
  64.     unsigned long vm_end;        /* The first byte after our end address
  65.                        within vm_mm. */
  66.  
  67.     /* linked list of VM areas per task, sorted by address */
  68.     struct vm_area_struct *vm_next;
  69.  
  70.     pgprot_t vm_page_prot;        /* Access permissions of this VMA. */
  71.     unsigned long vm_flags;        /* Flags, listed below. */
  72.  
  73.     struct rb_node vm_rb;
  74.  
  75.     /*
  76.      * For areas with an address space and backing store,
  77.      * linkage into the address_space->i_mmap prio tree, or
  78.      * linkage to the list of like vmas hanging off its node, or
  79.      * linkage of vma in the address_space->i_mmap_nonlinear list.
  80.      */
  81.     union {
  82.         struct {
  83.             struct list_head list;
  84.             void *parent;    /* aligns with prio_tree_node parent */
  85.             struct vm_area_struct *head;
  86.         } vm_set;
  87.  
  88.         struct raw_prio_tree_node prio_tree_node;
  89.     } shared;
  90.  
  91.     /*
  92.      * A file's MAP_PRIVATE vma can be in both i_mmap tree and anon_vma
  93.      * list, after a COW of one of the file pages.  A MAP_SHARED vma
  94.      * can only be in the i_mmap tree.  An anonymous MAP_PRIVATE, stack
  95.      * or brk vma (with NULL file) can only be in an anon_vma list.
  96.      */
  97.     struct list_head anon_vma_node;    /* Serialized by anon_vma->lock */
  98.     struct anon_vma *anon_vma;    /* Serialized by page_table_lock */
  99.  
  100.     /* Function pointers to deal with this struct. */
  101.     struct vm_operations_struct * vm_ops;
  102.  
  103.     /* Information about our backing store: */
  104.     unsigned long vm_pgoff;        /* Offset (within vm_file) in PAGE_SIZE
  105.                        units, *not* PAGE_CACHE_SIZE */
  106.     struct file * vm_file;        /* File we map to (can be NULL). */
  107.     void * vm_private_data;        /* was vm_pte (shared mem) */
  108.     unsigned long vm_truncate_count;/* truncate_count or restart_addr */
  109.  
  110. #ifndef CONFIG_MMU
  111.     atomic_t vm_usage;        /* refcount (VMAs shared if !MMU) */
  112. #endif
  113. #ifdef CONFIG_NUMA
  114.     struct mempolicy *vm_policy;    /* NUMA policy for the VMA */
  115. #endif
  116. };
  117.  
  118. /*
  119.  * This struct defines the per-mm list of VMAs for uClinux. If CONFIG_MMU is
  120.  * disabled, then there's a single shared list of VMAs maintained by the
  121.  * system, and mm's subscribe to these individually
  122.  */
  123. struct vm_list_struct {
  124.     struct vm_list_struct    *next;
  125.     struct vm_area_struct    *vma;
  126. };
  127.  
  128. #ifndef CONFIG_MMU
  129. extern struct rb_root nommu_vma_tree;
  130. extern struct rw_semaphore nommu_vma_sem;
  131.  
  132. extern unsigned int kobjsize(const void *objp);
  133. #endif
  134.  
  135. /*
  136.  * vm_flags..
  137.  */
  138. #define VM_READ        0x00000001    /* currently active flags */
  139. #define VM_WRITE    0x00000002
  140. #define VM_EXEC        0x00000004
  141. #define VM_SHARED    0x00000008
  142.  
  143. #define VM_MAYREAD    0x00000010    /* limits for mprotect() etc */
  144. #define VM_MAYWRITE    0x00000020
  145. #define VM_MAYEXEC    0x00000040
  146. #define VM_MAYSHARE    0x00000080
  147.  
  148. #define VM_GROWSDOWN    0x00000100    /* general info on the segment */
  149. #define VM_GROWSUP    0x00000200
  150. #define VM_SHM        0x00000400    /* shared memory area, don't swap out */
  151. #define VM_DENYWRITE    0x00000800    /* ETXTBSY on write attempts.. */
  152.  
  153. #define VM_EXECUTABLE    0x00001000
  154. #define VM_LOCKED    0x00002000
  155. #define VM_IO           0x00004000    /* Memory mapped I/O or similar */
  156.  
  157.                     /* Used by sys_madvise() */
  158. #define VM_SEQ_READ    0x00008000    /* App will access data sequentially */
  159. #define VM_RAND_READ    0x00010000    /* App will not benefit from clustered reads */
  160.  
  161. #define VM_DONTCOPY    0x00020000      /* Do not copy this vma on fork */
  162. #define VM_DONTEXPAND    0x00040000    /* Cannot expand with mremap() */
  163. #define VM_RESERVED    0x00080000    /* Don't unmap it from swap_out */
  164. #define VM_ACCOUNT    0x00100000    /* Is a VM accounted object */
  165. #define VM_HUGETLB    0x00400000    /* Huge TLB Page VM */
  166. #define VM_NONLINEAR    0x00800000    /* Is non-linear (remap_file_pages) */
  167.  
  168. #ifndef VM_STACK_DEFAULT_FLAGS        /* arch can override this */
  169. #define VM_STACK_DEFAULT_FLAGS VM_DATA_DEFAULT_FLAGS
  170. #endif
  171.  
  172. #ifdef CONFIG_STACK_GROWSUP
  173. #define VM_STACK_FLAGS    (VM_GROWSUP | VM_STACK_DEFAULT_FLAGS | VM_ACCOUNT)
  174. #else
  175. #define VM_STACK_FLAGS    (VM_GROWSDOWN | VM_STACK_DEFAULT_FLAGS | VM_ACCOUNT)
  176. #endif
  177.  
  178. #define VM_READHINTMASK            (VM_SEQ_READ | VM_RAND_READ)
  179. #define VM_ClearReadHint(v)        (v)->vm_flags &= ~VM_READHINTMASK
  180. #define VM_NormalReadHint(v)        (!((v)->vm_flags & VM_READHINTMASK))
  181. #define VM_SequentialReadHint(v)    ((v)->vm_flags & VM_SEQ_READ)
  182. #define VM_RandomReadHint(v)        ((v)->vm_flags & VM_RAND_READ)
  183.  
  184. /*
  185.  * mapping from the currently active vm_flags protection bits (the
  186.  * low four bits) to a page protection mask..
  187.  */
  188. extern pgprot_t protection_map[16];
  189.  
  190.  
  191. /*
  192.  * These are the virtual MM functions - opening of an area, closing and
  193.  * unmapping it (needed to keep files on disk up-to-date etc), pointer
  194.  * to the functions called when a no-page or a wp-page exception occurs. 
  195.  */
  196. struct vm_operations_struct {
  197.     void (*open)(struct vm_area_struct * area);
  198.     void (*close)(struct vm_area_struct * area);
  199.     struct page * (*nopage)(struct vm_area_struct * area, unsigned long address, int *type);
  200.     int (*populate)(struct vm_area_struct * area, unsigned long address, unsigned long len, pgprot_t prot, unsigned long pgoff, int nonblock);
  201. #ifdef CONFIG_NUMA
  202.     int (*set_policy)(struct vm_area_struct *vma, struct mempolicy *new);
  203.     struct mempolicy *(*get_policy)(struct vm_area_struct *vma,
  204.                     unsigned long addr);
  205. #endif
  206. };
  207.  
  208. struct mmu_gather;
  209. struct inode;
  210.  
  211. #ifdef ARCH_HAS_ATOMIC_UNSIGNED
  212. typedef unsigned page_flags_t;
  213. #else
  214. typedef unsigned long page_flags_t;
  215. #endif
  216.  
  217. /*
  218.  * Each physical page in the system has a struct page associated with
  219.  * it to keep track of whatever it is we are using the page for at the
  220.  * moment. Note that we have no way to track which tasks are using
  221.  * a page.
  222.  */
  223. struct page {
  224.     page_flags_t flags;        /* Atomic flags, some possibly
  225.                      * updated asynchronously */
  226.     atomic_t _count;        /* Usage count, see below. */
  227.     atomic_t _mapcount;        /* Count of ptes mapped in mms,
  228.                      * to show when page is mapped
  229.                      * & limit reverse map searches.
  230.                      */
  231.     unsigned long private;        /* Mapping-private opaque data:
  232.                      * usually used for buffer_heads
  233.                      * if PagePrivate set; used for
  234.                      * swp_entry_t if PageSwapCache
  235.                      * When page is free, this indicates
  236.                      * order in the buddy system.
  237.                      */
  238.     struct address_space *mapping;    /* If low bit clear, points to
  239.                      * inode address_space, or NULL.
  240.                      * If page mapped as anonymous
  241.                      * memory, low bit is set, and
  242.                      * it points to anon_vma object:
  243.                      * see PAGE_MAPPING_ANON below.
  244.                      */
  245.     pgoff_t index;            /* Our offset within mapping. */
  246.     struct list_head lru;        /* Pageout list, eg. active_list
  247.                      * protected by zone->lru_lock !
  248.                      */
  249.     /*
  250.      * On machines where all RAM is mapped into kernel address space,
  251.      * we can simply calculate the virtual address. On machines with
  252.      * highmem some memory is mapped into kernel virtual memory
  253.      * dynamically, so we need a place to store that address.
  254.      * Note that this field could be 16 bits on x86 ... ;)
  255.      *
  256.      * Architectures with slow multiplication can define
  257.      * WANT_PAGE_VIRTUAL in asm/page.h
  258.      */
  259. #if defined(WANT_PAGE_VIRTUAL)
  260.     void *virtual;            /* Kernel virtual address (NULL if
  261.                        not kmapped, ie. highmem) */
  262. #endif /* WANT_PAGE_VIRTUAL */
  263. };
  264.  
  265. /*
  266.  * FIXME: take this include out, include page-flags.h in
  267.  * files which need it (119 of them)
  268.  */
  269. #include <linux/page-flags.h>
  270.  
  271. /*
  272.  * Methods to modify the page usage count.
  273.  *
  274.  * What counts for a page usage:
  275.  * - cache mapping   (page->mapping)
  276.  * - private data    (page->private)
  277.  * - page mapped in a task's page tables, each mapping
  278.  *   is counted separately
  279.  *
  280.  * Also, many kernel routines increase the page count before a critical
  281.  * routine so they can be sure the page doesn't go away from under them.
  282.  *
  283.  * Since 2.6.6 (approx), a free page has ->_count = -1.  This is so that we
  284.  * can use atomic_add_negative(-1, page->_count) to detect when the page
  285.  * becomes free and so that we can also use atomic_inc_and_test to atomically
  286.  * detect when we just tried to grab a ref on a page which some other CPU has
  287.  * already deemed to be freeable.
  288.  *
  289.  * NO code should make assumptions about this internal detail!  Use the provided
  290.  * macros which retain the old rules: page_count(page) == 0 is a free page.
  291.  */
  292.  
  293. /*
  294.  * Drop a ref, return true if the logical refcount fell to zero (the page has
  295.  * no users)
  296.  */
  297. #define put_page_testzero(p)                \
  298.     ({                        \
  299.         BUG_ON(page_count(p) == 0);        \
  300.         atomic_add_negative(-1, &(p)->_count);    \
  301.     })
  302.  
  303. /*
  304.  * Grab a ref, return true if the page previously had a logical refcount of
  305.  * zero.  ie: returns true if we just grabbed an already-deemed-to-be-free page
  306.  */
  307. #define get_page_testone(p)    atomic_inc_and_test(&(p)->_count)
  308.  
  309. #define set_page_count(p,v)     atomic_set(&(p)->_count, v - 1)
  310. #define __put_page(p)        atomic_dec(&(p)->_count)
  311.  
  312. extern void FASTCALL(__page_cache_release(struct page *));
  313.  
  314. #ifdef CONFIG_HUGETLB_PAGE
  315.  
  316. static inline int page_count(struct page *p)
  317. {
  318.     if (PageCompound(p))
  319.         p = (struct page *)p->private;
  320.     return atomic_read(&(p)->_count) + 1;
  321. }
  322.  
  323. static inline void get_page(struct page *page)
  324. {
  325.     if (unlikely(PageCompound(page)))
  326.         page = (struct page *)page->private;
  327.     atomic_inc(&page->_count);
  328. }
  329.  
  330. void put_page(struct page *page);
  331.  
  332. #else        /* CONFIG_HUGETLB_PAGE */
  333.  
  334. #define page_count(p)        (atomic_read(&(p)->_count) + 1)
  335.  
  336. static inline void get_page(struct page *page)
  337. {
  338.     atomic_inc(&page->_count);
  339. }
  340.  
  341. static inline void put_page(struct page *page)
  342. {
  343.     if (!PageReserved(page) && put_page_testzero(page))
  344.         __page_cache_release(page);
  345. }
  346.  
  347. #endif        /* CONFIG_HUGETLB_PAGE */
  348.  
  349. /*
  350.  * Multiple processes may "see" the same page. E.g. for untouched
  351.  * mappings of /dev/null, all processes see the same page full of
  352.  * zeroes, and text pages of executables and shared libraries have
  353.  * only one copy in memory, at most, normally.
  354.  *
  355.  * For the non-reserved pages, page_count(page) denotes a reference count.
  356.  *   page_count() == 0 means the page is free.
  357.  *   page_count() == 1 means the page is used for exactly one purpose
  358.  *   (e.g. a private data page of one process).
  359.  *
  360.  * A page may be used for kmalloc() or anyone else who does a
  361.  * __get_free_page(). In this case the page_count() is at least 1, and
  362.  * all other fields are unused but should be 0 or NULL. The
  363.  * management of this page is the responsibility of the one who uses
  364.  * it.
  365.  *
  366.  * The other pages (we may call them "process pages") are completely
  367.  * managed by the Linux memory manager: I/O, buffers, swapping etc.
  368.  * The following discussion applies only to them.
  369.  *
  370.  * A page may belong to an inode's memory mapping. In this case,
  371.  * page->mapping is the pointer to the inode, and page->index is the
  372.  * file offset of the page, in units of PAGE_CACHE_SIZE.
  373.  *
  374.  * A page contains an opaque `private' member, which belongs to the
  375.  * page's address_space.  Usually, this is the address of a circular
  376.  * list of the page's disk buffers.
  377.  *
  378.  * For pages belonging to inodes, the page_count() is the number of
  379.  * attaches, plus 1 if `private' contains something, plus one for
  380.  * the page cache itself.
  381.  *
  382.  * All pages belonging to an inode are in these doubly linked lists:
  383.  * mapping->clean_pages, mapping->dirty_pages and mapping->locked_pages;
  384.  * using the page->list list_head. These fields are also used for
  385.  * freelist managemet (when page_count()==0).
  386.  *
  387.  * There is also a per-mapping radix tree mapping index to the page
  388.  * in memory if present. The tree is rooted at mapping->root.  
  389.  *
  390.  * All process pages can do I/O:
  391.  * - inode pages may need to be read from disk,
  392.  * - inode pages which have been modified and are MAP_SHARED may need
  393.  *   to be written to disk,
  394.  * - private pages which have been modified may need to be swapped out
  395.  *   to swap space and (later) to be read back into memory.
  396.  */
  397.  
  398. /*
  399.  * The zone field is never updated after free_area_init_core()
  400.  * sets it, so none of the operations on it need to be atomic.
  401.  * We'll have up to (MAX_NUMNODES * MAX_NR_ZONES) zones total,
  402.  * so we use (MAX_NODES_SHIFT + MAX_ZONES_SHIFT) here to get enough bits.
  403.  */
  404. #define NODEZONE_SHIFT (sizeof(page_flags_t)*8 - MAX_NODES_SHIFT - MAX_ZONES_SHIFT)
  405. #define NODEZONE(node, zone)    ((node << ZONES_SHIFT) | zone)
  406.  
  407. static inline unsigned long page_zonenum(struct page *page)
  408. {
  409.     return (page->flags >> NODEZONE_SHIFT) & (~(~0UL << ZONES_SHIFT));
  410. }
  411. static inline unsigned long page_to_nid(struct page *page)
  412. {
  413.     return (page->flags >> (NODEZONE_SHIFT + ZONES_SHIFT));
  414. }
  415.  
  416. struct zone;
  417. extern struct zone *zone_table[];
  418.  
  419. static inline struct zone *page_zone(struct page *page)
  420. {
  421.     return zone_table[page->flags >> NODEZONE_SHIFT];
  422. }
  423.  
  424. static inline void set_page_zone(struct page *page, unsigned long nodezone_num)
  425. {
  426.     page->flags &= ~(~0UL << NODEZONE_SHIFT);
  427.     page->flags |= nodezone_num << NODEZONE_SHIFT;
  428. }
  429.  
  430. #ifndef CONFIG_DISCONTIGMEM
  431. /* The array of struct pages - for discontigmem use pgdat->lmem_map */
  432. extern struct page *mem_map;
  433. #endif
  434.  
  435. static inline void *lowmem_page_address(struct page *page)
  436. {
  437.     return __va(page_to_pfn(page) << PAGE_SHIFT);
  438. }
  439.  
  440. #if defined(CONFIG_HIGHMEM) && !defined(WANT_PAGE_VIRTUAL)
  441. #define HASHED_PAGE_VIRTUAL
  442. #endif
  443.  
  444. #if defined(WANT_PAGE_VIRTUAL)
  445. #define page_address(page) ((page)->virtual)
  446. #define set_page_address(page, address)            \
  447.     do {                        \
  448.         (page)->virtual = (address);        \
  449.     } while(0)
  450. #define page_address_init()  do { } while(0)
  451. #endif
  452.  
  453. #if defined(HASHED_PAGE_VIRTUAL)
  454. void *page_address(struct page *page);
  455. void set_page_address(struct page *page, void *virtual);
  456. void page_address_init(void);
  457. #endif
  458.  
  459. #if !defined(HASHED_PAGE_VIRTUAL) && !defined(WANT_PAGE_VIRTUAL)
  460. #define page_address(page) lowmem_page_address(page)
  461. #define set_page_address(page, address)  do { } while(0)
  462. #define page_address_init()  do { } while(0)
  463. #endif
  464.  
  465. /*
  466.  * On an anonymous page mapped into a user virtual memory area,
  467.  * page->mapping points to its anon_vma, not to a struct address_space;
  468.  * with the PAGE_MAPPING_ANON bit set to distinguish it.
  469.  *
  470.  * Please note that, confusingly, "page_mapping" refers to the inode
  471.  * address_space which maps the page from disk; whereas "page_mapped"
  472.  * refers to user virtual address space into which the page is mapped.
  473.  */
  474. #define PAGE_MAPPING_ANON    1
  475.  
  476. extern struct address_space swapper_space;
  477. static inline struct address_space *page_mapping(struct page *page)
  478. {
  479.     struct address_space *mapping = page->mapping;
  480.  
  481.     if (unlikely(PageSwapCache(page)))
  482.         mapping = &swapper_space;
  483.     else if (unlikely((unsigned long)mapping & PAGE_MAPPING_ANON))
  484.         mapping = NULL;
  485.     return mapping;
  486. }
  487.  
  488. static inline int PageAnon(struct page *page)
  489. {
  490.     return ((unsigned long)page->mapping & PAGE_MAPPING_ANON) != 0;
  491. }
  492.  
  493. /*
  494.  * Return the pagecache index of the passed page.  Regular pagecache pages
  495.  * use ->index whereas swapcache pages use ->private
  496.  */
  497. static inline pgoff_t page_index(struct page *page)
  498. {
  499.     if (unlikely(PageSwapCache(page)))
  500.         return page->private;
  501.     return page->index;
  502. }
  503.  
  504. /*
  505.  * The atomic page->_mapcount, like _count, starts from -1:
  506.  * so that transitions both from it and to it can be tracked,
  507.  * using atomic_inc_and_test and atomic_add_negative(-1).
  508.  */
  509. static inline void reset_page_mapcount(struct page *page)
  510. {
  511.     atomic_set(&(page)->_mapcount, -1);
  512. }
  513.  
  514. static inline int page_mapcount(struct page *page)
  515. {
  516.     return atomic_read(&(page)->_mapcount) + 1;
  517. }
  518.  
  519. /*
  520.  * Return true if this page is mapped into pagetables.
  521.  */
  522. static inline int page_mapped(struct page *page)
  523. {
  524.     return atomic_read(&(page)->_mapcount) >= 0;
  525. }
  526.  
  527. /*
  528.  * Error return values for the *_nopage functions
  529.  */
  530. #define NOPAGE_SIGBUS    (NULL)
  531. #define NOPAGE_OOM    ((struct page *) (-1))
  532.  
  533. /*
  534.  * Different kinds of faults, as returned by handle_mm_fault().
  535.  * Used to decide whether a process gets delivered SIGBUS or
  536.  * just gets major/minor fault counters bumped up.
  537.  */
  538. #define VM_FAULT_OOM    (-1)
  539. #define VM_FAULT_SIGBUS    0
  540. #define VM_FAULT_MINOR    1
  541. #define VM_FAULT_MAJOR    2
  542.  
  543. #define offset_in_page(p)    ((unsigned long)(p) & ~PAGE_MASK)
  544.  
  545. extern void show_free_areas(void);
  546.  
  547. #ifdef CONFIG_SHMEM
  548. struct page *shmem_nopage(struct vm_area_struct *vma,
  549.             unsigned long address, int *type);
  550. int shmem_set_policy(struct vm_area_struct *vma, struct mempolicy *new);
  551. struct mempolicy *shmem_get_policy(struct vm_area_struct *vma,
  552.                     unsigned long addr);
  553. int shmem_lock(struct file *file, int lock, struct user_struct *user);
  554. #else
  555. #define shmem_nopage filemap_nopage
  556. #define shmem_lock(a, b, c)     ({0;})    /* always in memory, no need to lock */
  557. #define shmem_set_policy(a, b)    (0)
  558. #define shmem_get_policy(a, b)    (NULL)
  559. #endif
  560. struct file *shmem_file_setup(char *name, loff_t size, unsigned long flags);
  561.  
  562. int shmem_zero_setup(struct vm_area_struct *);
  563.  
  564. static inline int can_do_mlock(void)
  565. {
  566.     if (capable(CAP_IPC_LOCK))
  567.         return 1;
  568.     if (current->signal->rlim[RLIMIT_MEMLOCK].rlim_cur != 0)
  569.         return 1;
  570.     return 0;
  571. }
  572. extern int user_shm_lock(size_t, struct user_struct *);
  573. extern void user_shm_unlock(size_t, struct user_struct *);
  574.  
  575. /*
  576.  * Parameter block passed down to zap_pte_range in exceptional cases.
  577.  */
  578. struct zap_details {
  579.     struct vm_area_struct *nonlinear_vma;    /* Check page->index if set */
  580.     struct address_space *check_mapping;    /* Check page->mapping if set */
  581.     pgoff_t    first_index;            /* Lowest page->index to unmap */
  582.     pgoff_t last_index;            /* Highest page->index to unmap */
  583.     spinlock_t *i_mmap_lock;        /* For unmap_mapping_range: */
  584.     unsigned long break_addr;        /* Where unmap_vmas stopped */
  585.     unsigned long truncate_count;        /* Compare vm_truncate_count */
  586. };
  587.  
  588. void zap_page_range(struct vm_area_struct *vma, unsigned long address,
  589.         unsigned long size, struct zap_details *);
  590. int unmap_vmas(struct mmu_gather **tlbp, struct mm_struct *mm,
  591.         struct vm_area_struct *start_vma, unsigned long start_addr,
  592.         unsigned long end_addr, unsigned long *nr_accounted,
  593.         struct zap_details *);
  594. void clear_page_range(struct mmu_gather *tlb, unsigned long addr, unsigned long end);
  595. int copy_page_range(struct mm_struct *dst, struct mm_struct *src,
  596.             struct vm_area_struct *vma);
  597. int zeromap_page_range(struct vm_area_struct *vma, unsigned long from,
  598.             unsigned long size, pgprot_t prot);
  599. void unmap_mapping_range(struct address_space *mapping,
  600.         loff_t const holebegin, loff_t const holelen, int even_cows);
  601.  
  602. static inline void unmap_shared_mapping_range(struct address_space *mapping,
  603.         loff_t const holebegin, loff_t const holelen)
  604. {
  605.     unmap_mapping_range(mapping, holebegin, holelen, 0);
  606. }
  607.  
  608. extern int vmtruncate(struct inode * inode, loff_t offset);
  609. extern pud_t *FASTCALL(__pud_alloc(struct mm_struct *mm, pgd_t *pgd, unsigned long address));
  610. extern pmd_t *FASTCALL(__pmd_alloc(struct mm_struct *mm, pud_t *pud, unsigned long address));
  611. extern pte_t *FASTCALL(pte_alloc_kernel(struct mm_struct *mm, pmd_t *pmd, unsigned long address));
  612. extern pte_t *FASTCALL(pte_alloc_map(struct mm_struct *mm, pmd_t *pmd, unsigned long address));
  613. extern int install_page(struct mm_struct *mm, struct vm_area_struct *vma, unsigned long addr, struct page *page, pgprot_t prot);
  614. extern int install_file_pte(struct mm_struct *mm, struct vm_area_struct *vma, unsigned long addr, unsigned long pgoff, pgprot_t prot);
  615. extern int handle_mm_fault(struct mm_struct *mm,struct vm_area_struct *vma, unsigned long address, int write_access);
  616. extern int make_pages_present(unsigned long addr, unsigned long end);
  617. extern int access_process_vm(struct task_struct *tsk, unsigned long addr, void *buf, int len, int write);
  618. void install_arg_page(struct vm_area_struct *, struct page *, unsigned long);
  619.  
  620. int get_user_pages(struct task_struct *tsk, struct mm_struct *mm, unsigned long start,
  621.         int len, int write, int force, struct page **pages, struct vm_area_struct **vmas);
  622.  
  623. int __set_page_dirty_buffers(struct page *page);
  624. int __set_page_dirty_nobuffers(struct page *page);
  625. int redirty_page_for_writepage(struct writeback_control *wbc,
  626.                 struct page *page);
  627. int FASTCALL(set_page_dirty(struct page *page));
  628. int set_page_dirty_lock(struct page *page);
  629. int clear_page_dirty_for_io(struct page *page);
  630.  
  631. extern unsigned long do_mremap(unsigned long addr,
  632.                    unsigned long old_len, unsigned long new_len,
  633.                    unsigned long flags, unsigned long new_addr);
  634.  
  635. /*
  636.  * Prototype to add a shrinker callback for ageable caches.
  637.  * 
  638.  * These functions are passed a count `nr_to_scan' and a gfpmask.  They should
  639.  * scan `nr_to_scan' objects, attempting to free them.
  640.  *
  641.  * The callback must the number of objects which remain in the cache.
  642.  *
  643.  * The callback will be passes nr_to_scan == 0 when the VM is querying the
  644.  * cache size, so a fastpath for that case is appropriate.
  645.  */
  646. typedef int (*shrinker_t)(int nr_to_scan, unsigned int gfp_mask);
  647.  
  648. /*
  649.  * Add an aging callback.  The int is the number of 'seeks' it takes
  650.  * to recreate one of the objects that these functions age.
  651.  */
  652.  
  653. #define DEFAULT_SEEKS 2
  654. struct shrinker;
  655. extern struct shrinker *set_shrinker(int, shrinker_t);
  656. extern void remove_shrinker(struct shrinker *shrinker);
  657.  
  658. /*
  659.  * On a two-level or three-level page table, this ends up being trivial. Thus
  660.  * the inlining and the symmetry break with pte_alloc_map() that does all
  661.  * of this out-of-line.
  662.  */
  663. /*
  664.  * The following ifdef needed to get the 4level-fixup.h header to work.
  665.  * Remove it when 4level-fixup.h has been removed.
  666.  */
  667. #ifdef CONFIG_MMU
  668. #ifndef __ARCH_HAS_4LEVEL_HACK 
  669. static inline pud_t *pud_alloc(struct mm_struct *mm, pgd_t *pgd, unsigned long address)
  670. {
  671.     if (pgd_none(*pgd))
  672.         return __pud_alloc(mm, pgd, address);
  673.     return pud_offset(pgd, address);
  674. }
  675.  
  676. static inline pmd_t *pmd_alloc(struct mm_struct *mm, pud_t *pud, unsigned long address)
  677. {
  678.     if (pud_none(*pud))
  679.         return __pmd_alloc(mm, pud, address);
  680.     return pmd_offset(pud, address);
  681. }
  682. #endif
  683. #endif /* CONFIG_MMU */
  684.  
  685. extern void free_area_init(unsigned long * zones_size);
  686. extern void free_area_init_node(int nid, pg_data_t *pgdat,
  687.     unsigned long * zones_size, unsigned long zone_start_pfn, 
  688.     unsigned long *zholes_size);
  689. extern void memmap_init_zone(unsigned long, int, unsigned long, unsigned long);
  690. extern void mem_init(void);
  691. extern void show_mem(void);
  692. extern void si_meminfo(struct sysinfo * val);
  693. extern void si_meminfo_node(struct sysinfo *val, int nid);
  694.  
  695. /* prio_tree.c */
  696. void vma_prio_tree_add(struct vm_area_struct *, struct vm_area_struct *old);
  697. void vma_prio_tree_insert(struct vm_area_struct *, struct prio_tree_root *);
  698. void vma_prio_tree_remove(struct vm_area_struct *, struct prio_tree_root *);
  699. struct vm_area_struct *vma_prio_tree_next(struct vm_area_struct *vma,
  700.     struct prio_tree_iter *iter);
  701.  
  702. #define vma_prio_tree_foreach(vma, iter, root, begin, end)    \
  703.     for (prio_tree_iter_init(iter, root, begin, end), vma = NULL;    \
  704.         (vma = vma_prio_tree_next(vma, iter)); )
  705.  
  706. static inline void vma_nonlinear_insert(struct vm_area_struct *vma,
  707.                     struct list_head *list)
  708. {
  709.     vma->shared.vm_set.parent = NULL;
  710.     list_add_tail(&vma->shared.vm_set.list, list);
  711. }
  712.  
  713. /* mmap.c */
  714. extern int __vm_enough_memory(long pages, int cap_sys_admin);
  715. extern void vma_adjust(struct vm_area_struct *vma, unsigned long start,
  716.     unsigned long end, pgoff_t pgoff, struct vm_area_struct *insert);
  717. extern struct vm_area_struct *vma_merge(struct mm_struct *,
  718.     struct vm_area_struct *prev, unsigned long addr, unsigned long end,
  719.     unsigned long vm_flags, struct anon_vma *, struct file *, pgoff_t,
  720.     struct mempolicy *);
  721. extern struct anon_vma *find_mergeable_anon_vma(struct vm_area_struct *);
  722. extern int split_vma(struct mm_struct *,
  723.     struct vm_area_struct *, unsigned long addr, int new_below);
  724. extern int insert_vm_struct(struct mm_struct *, struct vm_area_struct *);
  725. extern void __vma_link_rb(struct mm_struct *, struct vm_area_struct *,
  726.     struct rb_node **, struct rb_node *);
  727. extern struct vm_area_struct *copy_vma(struct vm_area_struct **,
  728.     unsigned long addr, unsigned long len, pgoff_t pgoff);
  729. extern void exit_mmap(struct mm_struct *);
  730.  
  731. extern unsigned long get_unmapped_area(struct file *, unsigned long, unsigned long, unsigned long, unsigned long);
  732.  
  733. extern unsigned long do_mmap_pgoff(struct file *file, unsigned long addr,
  734.     unsigned long len, unsigned long prot,
  735.     unsigned long flag, unsigned long pgoff);
  736.  
  737. static inline unsigned long do_mmap(struct file *file, unsigned long addr,
  738.     unsigned long len, unsigned long prot,
  739.     unsigned long flag, unsigned long offset)
  740. {
  741.     unsigned long ret = -EINVAL;
  742.     if ((offset + PAGE_ALIGN(len)) < offset)
  743.         goto out;
  744.     if (!(offset & ~PAGE_MASK))
  745.         ret = do_mmap_pgoff(file, addr, len, prot, flag, offset >> PAGE_SHIFT);
  746. out:
  747.     return ret;
  748. }
  749.  
  750. extern int do_munmap(struct mm_struct *, unsigned long, size_t);
  751.  
  752. extern unsigned long do_brk(unsigned long, unsigned long);
  753.  
  754. /* filemap.c */
  755. extern unsigned long page_unuse(struct page *);
  756. extern void truncate_inode_pages(struct address_space *, loff_t);
  757.  
  758. /* generic vm_area_ops exported for stackable file systems */
  759. extern struct page *filemap_nopage(struct vm_area_struct *, unsigned long, int *);
  760. extern int filemap_populate(struct vm_area_struct *, unsigned long,
  761.         unsigned long, pgprot_t, unsigned long, int);
  762.  
  763. /* mm/page-writeback.c */
  764. int write_one_page(struct page *page, int wait);
  765.  
  766. /* readahead.c */
  767. #define VM_MAX_READAHEAD    128    /* kbytes */
  768. #define VM_MIN_READAHEAD    16    /* kbytes (includes current page) */
  769. #define VM_MAX_CACHE_HIT        256    /* max pages in a row in cache before
  770.                      * turning readahead off */
  771.  
  772. int do_page_cache_readahead(struct address_space *mapping, struct file *filp,
  773.             unsigned long offset, unsigned long nr_to_read);
  774. int force_page_cache_readahead(struct address_space *mapping, struct file *filp,
  775.             unsigned long offset, unsigned long nr_to_read);
  776. unsigned long  page_cache_readahead(struct address_space *mapping,
  777.               struct file_ra_state *ra,
  778.               struct file *filp,
  779.               unsigned long offset,
  780.               unsigned long size);
  781. void handle_ra_miss(struct address_space *mapping, 
  782.             struct file_ra_state *ra, pgoff_t offset);
  783. unsigned long max_sane_readahead(unsigned long nr);
  784.  
  785. /* Do stack extension */
  786. extern int expand_stack(struct vm_area_struct * vma, unsigned long address);
  787.  
  788. /* Look up the first VMA which satisfies  addr < vm_end,  NULL if none. */
  789. extern struct vm_area_struct * find_vma(struct mm_struct * mm, unsigned long addr);
  790. extern struct vm_area_struct * find_vma_prev(struct mm_struct * mm, unsigned long addr,
  791.                          struct vm_area_struct **pprev);
  792.  
  793. /* Look up the first VMA which intersects the interval start_addr..end_addr-1,
  794.    NULL if none.  Assume start_addr < end_addr. */
  795. static inline struct vm_area_struct * find_vma_intersection(struct mm_struct * mm, unsigned long start_addr, unsigned long end_addr)
  796. {
  797.     struct vm_area_struct * vma = find_vma(mm,start_addr);
  798.  
  799.     if (vma && end_addr <= vma->vm_start)
  800.         vma = NULL;
  801.     return vma;
  802. }
  803.  
  804. static inline unsigned long vma_pages(struct vm_area_struct *vma)
  805. {
  806.     return (vma->vm_end - vma->vm_start) >> PAGE_SHIFT;
  807. }
  808.  
  809. extern struct vm_area_struct *find_extend_vma(struct mm_struct *mm, unsigned long addr);
  810.  
  811. extern struct page * vmalloc_to_page(void *addr);
  812. extern unsigned long vmalloc_to_pfn(void *addr);
  813. extern struct page * follow_page(struct mm_struct *mm, unsigned long address,
  814.         int write);
  815. extern int check_user_page_readable(struct mm_struct *mm, unsigned long address);
  816. int remap_pfn_range(struct vm_area_struct *, unsigned long,
  817.         unsigned long, unsigned long, pgprot_t);
  818.  
  819. #ifdef CONFIG_PROC_FS
  820. void __vm_stat_account(struct mm_struct *, unsigned long, struct file *, long);
  821. #else
  822. static inline void __vm_stat_account(struct mm_struct *mm,
  823.             unsigned long flags, struct file *file, long pages)
  824. {
  825. }
  826. #endif /* CONFIG_PROC_FS */
  827.  
  828. static inline void vm_stat_account(struct vm_area_struct *vma)
  829. {
  830.     __vm_stat_account(vma->vm_mm, vma->vm_flags, vma->vm_file,
  831.                             vma_pages(vma));
  832. }
  833.  
  834. static inline void vm_stat_unaccount(struct vm_area_struct *vma)
  835. {
  836.     __vm_stat_account(vma->vm_mm, vma->vm_flags, vma->vm_file,
  837.                             -vma_pages(vma));
  838. }
  839.  
  840. /* update per process rss and vm hiwater data */
  841. extern void update_mem_hiwater(void);
  842.  
  843. #ifndef CONFIG_DEBUG_PAGEALLOC
  844. static inline void
  845. kernel_map_pages(struct page *page, int numpages, int enable)
  846. {
  847. }
  848. #endif
  849.  
  850. extern struct vm_area_struct *get_gate_vma(struct task_struct *tsk);
  851. #ifdef    __HAVE_ARCH_GATE_AREA
  852. int in_gate_area_no_task(unsigned long addr);
  853. int in_gate_area(struct task_struct *task, unsigned long addr);
  854. #else
  855. int in_gate_area_no_task(unsigned long addr);
  856. #define in_gate_area(task, addr) ({(void)task; in_gate_area_no_task(addr);})
  857. #endif    /* __HAVE_ARCH_GATE_AREA */
  858.  
  859. #endif /* __KERNEL__ */
  860. #endif /* _LINUX_MM_H */
  861.